﻿using System;
using System.ComponentModel;
using System.Reflection;
using System.Runtime.InteropServices;

namespace Teigha.Core
{
	public class OdGsBaseVectorizeDevice : OdGsDevice
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public OdGsBaseVectorizeDevice(IntPtr cPtr, bool cMemoryOwn) : base(GlobalsPINVOKE.OdGsBaseVectorizeDevice_SWIGUpcast(cPtr), cMemoryOwn)
		{
			this.swigCPtr = new HandleRef(this, cPtr);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static HandleRef getCPtr(OdGsBaseVectorizeDevice obj)
		{
			if (obj != null)
			{
				return obj.swigCPtr;
			}
			return new HandleRef(null, IntPtr.Zero);
		}

		~OdGsBaseVectorizeDevice()
		{
			this.Dispose();
		}

		public new virtual void Dispose()
		{
			if (this.swigCPtr.Handle != IntPtr.Zero)
			{
				if (this.swigCMemOwn)
				{
					lock (this.locker)
					{
						if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
						{
							this.swigCMemOwn = false;
							GlobalsPINVOKE.delete_OdGsBaseVectorizeDevice(this.swigCPtr);
						}
					}
					this.swigCMemOwn = false;
				}
				this.swigCPtr = new HandleRef(null, IntPtr.Zero);
			}
			GC.SuppressFinalize(this);
		}

		public OdGsBaseVectorizeDevice() : this(GlobalsPINVOKE.new_OdGsBaseVectorizeDevice(), MemoryManager.GetMemoryManager().GetCurrentTransaction() == null)
		{
			MemoryTransaction currentTransaction = MemoryManager.GetMemoryManager().GetCurrentTransaction();
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdGsBaseVectorizeDevice(this.swigCPtr.Handle, true));
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			this.SwigDirectorConnect();
		}

		public void setValid(bool bFlag)
		{
			GlobalsPINVOKE.OdGsBaseVectorizeDevice_setValid(this.swigCPtr, bFlag);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool supportPartialUpdate()
		{
			bool result = this.SwigDerivedClassHasMethod("supportPartialUpdate", OdGsBaseVectorizeDevice.swigMethodTypes0) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_supportPartialUpdateSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_supportPartialUpdate(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdGsBaseVectorizeDevice cast(OdRxObject pObj)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.OdGsBaseVectorizeDevice_cast(OdRxObject.getCPtr(pObj));
			OdGsBaseVectorizeDevice result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsBaseVectorizeDevice)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsBaseVectorizeDevice)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsBaseVectorizeDevice)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdRxClass desc()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsBaseVectorizeDevice_desc(), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxClass isA()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(this.SwigDerivedClassHasMethod("isA", OdGsBaseVectorizeDevice.swigMethodTypes1) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_isASwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_isA(this.swigCPtr), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxObject queryX(OdRxClass protocolClass)
		{
			OdRxObject result = Teigha.Core.Helpers.odrxCreateObjectInternal(this.SwigDerivedClassHasMethod("queryX", OdGsBaseVectorizeDevice.swigMethodTypes2) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_queryXSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr, OdRxClass.getCPtr(protocolClass)) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_queryX(this.swigCPtr, OdRxClass.getCPtr(protocolClass)), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdGsBaseVectorizeDevice createObject()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.OdGsBaseVectorizeDevice_createObject();
			OdGsBaseVectorizeDevice result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsBaseVectorizeDevice)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsBaseVectorizeDevice)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsBaseVectorizeDevice)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdGiContext userGiContext()
		{
			OdGiContext result = (OdGiContext)Teigha.Core.Helpers.odrxCreateObjectInternal(this.SwigDerivedClassHasMethod("userGiContext", OdGsBaseVectorizeDevice.swigMethodTypes3) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_userGiContextSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_userGiContext(this.swigCPtr), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void setUserGiContext(OdGiContext pUserGiContext)
		{
			if (this.SwigDerivedClassHasMethod("setUserGiContext", OdGsBaseVectorizeDevice.swigMethodTypes4))
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_setUserGiContextSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr, OdGiContext.getCPtr(pUserGiContext));
			}
			else
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_setUserGiContext(this.swigCPtr, OdGiContext.getCPtr(pUserGiContext));
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdRxDictionary properties()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = this.SwigDerivedClassHasMethod("properties", OdGsBaseVectorizeDevice.swigMethodTypes5) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_propertiesSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_properties(this.swigCPtr);
			OdRxDictionary result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdRxDictionary)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdRxDictionary)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdRxDictionary)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void invalidate(OdGsDCRect screenRect)
		{
			if (this.SwigDerivedClassHasMethod("invalidate", OdGsBaseVectorizeDevice.swigMethodTypes6))
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_invalidateSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr, OdGsDCRect.getCPtr(screenRect));
			}
			else
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_invalidate(this.swigCPtr, OdGsDCRect.getCPtr(screenRect));
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void update(OdGsDCRect pUpdatedRect)
		{
			if (this.SwigDerivedClassHasMethod("update", OdGsBaseVectorizeDevice.swigMethodTypes7))
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_updateSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr, OdGsDCRect.getCPtr(pUpdatedRect));
			}
			else
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_update(this.swigCPtr, OdGsDCRect.getCPtr(pUpdatedRect));
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void updateGeometry()
		{
			if (this.SwigDerivedClassHasMethod("updateGeometry", OdGsBaseVectorizeDevice.swigMethodTypes8))
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_updateGeometrySwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr);
			}
			else
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_updateGeometry(this.swigCPtr);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void updateScreen()
		{
			if (this.SwigDerivedClassHasMethod("updateScreen", OdGsBaseVectorizeDevice.swigMethodTypes9))
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_updateScreenSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr);
			}
			else
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_updateScreen(this.swigCPtr);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void onRealizeForegroundPalette()
		{
			if (this.SwigDerivedClassHasMethod("onRealizeForegroundPalette", OdGsBaseVectorizeDevice.swigMethodTypes10))
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_onRealizeForegroundPaletteSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr);
			}
			else
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_onRealizeForegroundPalette(this.swigCPtr);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void onRealizeBackgroundPalette()
		{
			if (this.SwigDerivedClassHasMethod("onRealizeBackgroundPalette", OdGsBaseVectorizeDevice.swigMethodTypes11))
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_onRealizeBackgroundPaletteSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr);
			}
			else
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_onRealizeBackgroundPalette(this.swigCPtr);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void onDisplayChange(int bitsPerPixel, int xPixels, int yPixels)
		{
			if (this.SwigDerivedClassHasMethod("onDisplayChange", OdGsBaseVectorizeDevice.swigMethodTypes12))
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_onDisplayChangeSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr, bitsPerPixel, xPixels, yPixels);
			}
			else
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_onDisplayChange(this.swigCPtr, bitsPerPixel, xPixels, yPixels);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdGsView createView(OdGsClientViewInfo pViewInfo, bool enableLayerVisibilityPerView)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = this.SwigDerivedClassHasMethod("createView", OdGsBaseVectorizeDevice.swigMethodTypes13) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_createViewSwigExplicitOdGsBaseVectorizeDevice__SWIG_0(this.swigCPtr, OdGsClientViewInfo.getCPtr(pViewInfo), enableLayerVisibilityPerView) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_createView__SWIG_0(this.swigCPtr, OdGsClientViewInfo.getCPtr(pViewInfo), enableLayerVisibilityPerView);
			OdGsView result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdGsView createView(OdGsClientViewInfo pViewInfo)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = this.SwigDerivedClassHasMethod("createView", OdGsBaseVectorizeDevice.swigMethodTypes14) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_createViewSwigExplicitOdGsBaseVectorizeDevice__SWIG_1(this.swigCPtr, OdGsClientViewInfo.getCPtr(pViewInfo)) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_createView__SWIG_1(this.swigCPtr, OdGsClientViewInfo.getCPtr(pViewInfo));
			OdGsView result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdGsView createView()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = this.SwigDerivedClassHasMethod("createView", OdGsBaseVectorizeDevice.swigMethodTypes15) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_createViewSwigExplicitOdGsBaseVectorizeDevice__SWIG_2(this.swigCPtr) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_createView__SWIG_2(this.swigCPtr);
			OdGsView result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void addView(OdGsView pView)
		{
			if (this.SwigDerivedClassHasMethod("addView", OdGsBaseVectorizeDevice.swigMethodTypes16))
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_addViewSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr, OdGsView.getCPtr(pView));
			}
			else
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_addView(this.swigCPtr, OdGsView.getCPtr(pView));
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void insertView(int viewIndex, OdGsView pView)
		{
			if (this.SwigDerivedClassHasMethod("insertView", OdGsBaseVectorizeDevice.swigMethodTypes17))
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_insertViewSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr, viewIndex, OdGsView.getCPtr(pView));
			}
			else
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_insertView(this.swigCPtr, viewIndex, OdGsView.getCPtr(pView));
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void setLogicalPalette(uint[] logicalPalette, int numColors)
		{
			if (this.SwigDerivedClassHasMethod("setLogicalPalette", OdGsBaseVectorizeDevice.swigMethodTypes18))
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_setLogicalPaletteSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr, logicalPalette, numColors);
			}
			else
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_setLogicalPalette(this.swigCPtr, logicalPalette, numColors);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void getSnapShot(out OdGiRasterImage pImage, OdGsDCRect region)
		{
			IntPtr zero = IntPtr.Zero;
			try
			{
				if (this.SwigDerivedClassHasMethod("getSnapShot", OdGsBaseVectorizeDevice.swigMethodTypes19))
				{
					GlobalsPINVOKE.OdGsBaseVectorizeDevice_getSnapShotSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr, out zero, OdGsDCRect.getCPtr(region));
				}
				else
				{
					GlobalsPINVOKE.OdGsBaseVectorizeDevice_getSnapShot(this.swigCPtr, out zero, OdGsDCRect.getCPtr(region));
				}
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}
			finally
			{
				pImage = (OdGiRasterImage)Teigha.Core.Helpers.odrxCreateObjectInternal(zero, true);
			}
		}

		public uint getColor(ushort colorIndex)
		{
			uint result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_getColor(this.swigCPtr, colorIndex);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdGsModel createModel()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = this.SwigDerivedClassHasMethod("createModel", OdGsBaseVectorizeDevice.swigMethodTypes20) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_createModelSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_createModel(this.swigCPtr);
			OdGsModel result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsModel)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsModel)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsModel)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual bool isModelCompatible(OdGsModel pModel)
		{
			bool result = this.SwigDerivedClassHasMethod("isModelCompatible", OdGsBaseVectorizeDevice.swigMethodTypes21) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_isModelCompatibleSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr, OdGsModel.getCPtr(pModel)) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_isModelCompatible(this.swigCPtr, OdGsModel.getCPtr(pModel));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGsView rootView()
		{
			OdGsView result = (OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsBaseVectorizeDevice_rootView(this.swigCPtr), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool sortRenderTypes()
		{
			bool result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_sortRenderTypes(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setSortRenderTypes(bool flag)
		{
			GlobalsPINVOKE.OdGsBaseVectorizeDevice_setSortRenderTypes(this.swigCPtr, flag);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual uint renderTypeWeight(OdGsModel.RenderType renderType)
		{
			uint result = this.SwigDerivedClassHasMethod("renderTypeWeight", OdGsBaseVectorizeDevice.swigMethodTypes22) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_renderTypeWeightSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr, (int)renderType) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_renderTypeWeight(this.swigCPtr, (int)renderType);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdGsModel.RenderType transientRenderType()
		{
			OdGsModel.RenderType result = (OdGsModel.RenderType)(this.SwigDerivedClassHasMethod("transientRenderType", OdGsBaseVectorizeDevice.swigMethodTypes23) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_transientRenderTypeSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_transientRenderType(this.swigCPtr));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool supportOverlays()
		{
			bool result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_supportOverlays(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setSupportOverlays(bool bFlag)
		{
			GlobalsPINVOKE.OdGsBaseVectorizeDevice_setSupportOverlays(this.swigCPtr, bFlag);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual uint renderTypeOverlay(OdGsModel.RenderType renderType)
		{
			uint result = this.SwigDerivedClassHasMethod("renderTypeOverlay", OdGsBaseVectorizeDevice.swigMethodTypes24) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_renderTypeOverlaySwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr, (int)renderType) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_renderTypeOverlay(this.swigCPtr, (int)renderType);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isOverlayInvalid(uint nOverlay)
		{
			bool result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_isOverlayInvalid(this.swigCPtr, nOverlay);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setOverlayInvalid(uint nOverlay, bool bFlag)
		{
			GlobalsPINVOKE.OdGsBaseVectorizeDevice_setOverlayInvalid(this.swigCPtr, nOverlay, bFlag);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void resetOverlayFlags(bool bFlag)
		{
			GlobalsPINVOKE.OdGsBaseVectorizeDevice_resetOverlayFlags__SWIG_0(this.swigCPtr, bFlag);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void resetOverlayFlags()
		{
			GlobalsPINVOKE.OdGsBaseVectorizeDevice_resetOverlayFlags__SWIG_1(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isSpatialIndexDisabled()
		{
			bool result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_isSpatialIndexDisabled(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void disableSpatialIndex(bool bSet)
		{
			GlobalsPINVOKE.OdGsBaseVectorizeDevice_disableSpatialIndex(this.swigCPtr, bSet);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isCullingVolumeEnabled()
		{
			bool result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_isCullingVolumeEnabled(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void enableCullingVolume(bool bSet)
		{
			GlobalsPINVOKE.OdGsBaseVectorizeDevice_enableCullingVolume(this.swigCPtr, bSet);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool supportDynamicHighlight()
		{
			bool result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_supportDynamicHighlight(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool supportDynamicSubhighlight()
		{
			bool result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_supportDynamicSubhighlight(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool supportBlocks()
		{
			bool result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_supportBlocks(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool supportComposition()
		{
			bool result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_supportComposition(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool compositionEnabled()
		{
			bool result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_compositionEnabled(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void enableComposition(bool bSet)
		{
			GlobalsPINVOKE.OdGsBaseVectorizeDevice_enableComposition(this.swigCPtr, bSet);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isDisplayOffLayersEnabled()
		{
			bool result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_isDisplayOffLayersEnabled(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void enableDisplayOffLayers(bool bSet)
		{
			GlobalsPINVOKE.OdGsBaseVectorizeDevice_enableDisplayOffLayers(this.swigCPtr, bSet);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isValidViewportId(uint acgiId)
		{
			bool result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_isValidViewportId(this.swigCPtr, acgiId);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool useVpLtypeScaleMult()
		{
			bool result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_useVpLtypeScaleMult(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool useVpFilterFunction()
		{
			bool result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_useVpFilterFunction(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGiSectionGeometryManager getSectionGeometryManager()
		{
			OdGiSectionGeometryManager result = (OdGiSectionGeometryManager)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsBaseVectorizeDevice_getSectionGeometryManager(this.swigCPtr), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdRxObject getSectionGeometryMap()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.OdGsBaseVectorizeDevice_getSectionGeometryMap(this.swigCPtr);
			OdRxObject result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void clearSectionGeometryMap()
		{
			GlobalsPINVOKE.OdGsBaseVectorizeDevice_clearSectionGeometryMap(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdRxObject mtServices()
		{
			OdRxObject result = Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsBaseVectorizeDevice_mtServices(this.swigCPtr), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGiTransientManager transientManager()
		{
			IntPtr intPtr = GlobalsPINVOKE.OdGsBaseVectorizeDevice_transientManager(this.swigCPtr);
			OdGiTransientManager result = (intPtr == IntPtr.Zero) ? null : new OdGiTransientManager(intPtr, false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setTransientManager(OdGiTransientManager pManager)
		{
			GlobalsPINVOKE.OdGsBaseVectorizeDevice_setTransientManager(this.swigCPtr, OdGiTransientManager.getCPtr(pManager));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool isSupportDeviceStateSaving()
		{
			bool result = this.SwigDerivedClassHasMethod("isSupportDeviceStateSaving", OdGsBaseVectorizeDevice.swigMethodTypes25) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_isSupportDeviceStateSavingSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_isSupportDeviceStateSaving(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new bool saveDeviceState(SWIGTYPE_p_OdGsFiler pFiler)
		{
			bool result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_saveDeviceState(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new bool loadDeviceState(SWIGTYPE_p_OdGsFiler pFiler)
		{
			bool result = GlobalsPINVOKE.OdGsBaseVectorizeDevice_loadDeviceState(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool saveClientDeviceState(SWIGTYPE_p_OdGsFiler pFiler)
		{
			bool result = this.SwigDerivedClassHasMethod("saveClientDeviceState", OdGsBaseVectorizeDevice.swigMethodTypes26) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_saveClientDeviceStateSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler)) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_saveClientDeviceState(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool loadClientDeviceState(SWIGTYPE_p_OdGsFiler pFiler)
		{
			bool result = this.SwigDerivedClassHasMethod("loadClientDeviceState", OdGsBaseVectorizeDevice.swigMethodTypes27) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_loadClientDeviceStateSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler)) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_loadClientDeviceState(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool saveLinkedDeviceState(SWIGTYPE_p_OdGsFiler pFiler)
		{
			bool result = this.SwigDerivedClassHasMethod("saveLinkedDeviceState", OdGsBaseVectorizeDevice.swigMethodTypes28) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_saveLinkedDeviceStateSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler)) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_saveLinkedDeviceState(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool loadLinkedDeviceState(SWIGTYPE_p_OdGsFiler pFiler)
		{
			bool result = this.SwigDerivedClassHasMethod("loadLinkedDeviceState", OdGsBaseVectorizeDevice.swigMethodTypes29) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_loadLinkedDeviceStateSwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler)) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_loadLinkedDeviceState(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		protected virtual bool supportParallelDisplay()
		{
			bool result = this.SwigDerivedClassHasMethod("supportParallelDisplay", OdGsBaseVectorizeDevice.swigMethodTypes30) ? GlobalsPINVOKE.OdGsBaseVectorizeDevice_supportParallelDisplaySwigExplicitOdGsBaseVectorizeDevice(this.swigCPtr) : GlobalsPINVOKE.OdGsBaseVectorizeDevice_supportParallelDisplay(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public GsVectPerformanceData m_vectPerfData
		{
			get
			{
				IntPtr intPtr = GlobalsPINVOKE.OdGsBaseVectorizeDevice_m_vectPerfData_get(this.swigCPtr);
				GsVectPerformanceData result = (intPtr == IntPtr.Zero) ? null : new GsVectPerformanceData(intPtr, false);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}
			set
			{
				GlobalsPINVOKE.OdGsBaseVectorizeDevice_m_vectPerfData_set(this.swigCPtr, GsVectPerformanceData.getCPtr(value));
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}
		}

		private void SwigDirectorConnect()
		{
			if (this.SwigDerivedClassHasMethod("supportPartialUpdate", OdGsBaseVectorizeDevice.swigMethodTypes0))
			{
				this.swigDelegate0 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_0(this.SwigDirectorsupportPartialUpdate);
			}
			if (this.SwigDerivedClassHasMethod("isA", OdGsBaseVectorizeDevice.swigMethodTypes1))
			{
				this.swigDelegate1 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_1(this.SwigDirectorisA);
			}
			if (this.SwigDerivedClassHasMethod("queryX", OdGsBaseVectorizeDevice.swigMethodTypes2))
			{
				this.swigDelegate2 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_2(this.SwigDirectorqueryX);
			}
			if (this.SwigDerivedClassHasMethod("userGiContext", OdGsBaseVectorizeDevice.swigMethodTypes3))
			{
				this.swigDelegate3 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_3(this.SwigDirectoruserGiContext);
			}
			if (this.SwigDerivedClassHasMethod("setUserGiContext", OdGsBaseVectorizeDevice.swigMethodTypes4))
			{
				this.swigDelegate4 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_4(this.SwigDirectorsetUserGiContext);
			}
			if (this.SwigDerivedClassHasMethod("properties", OdGsBaseVectorizeDevice.swigMethodTypes5))
			{
				this.swigDelegate5 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_5(this.SwigDirectorproperties);
			}
			if (this.SwigDerivedClassHasMethod("invalidate", OdGsBaseVectorizeDevice.swigMethodTypes6))
			{
				this.swigDelegate6 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_6(this.SwigDirectorinvalidate);
			}
			if (this.SwigDerivedClassHasMethod("update", OdGsBaseVectorizeDevice.swigMethodTypes7))
			{
				this.swigDelegate7 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_7(this.SwigDirectorupdate);
			}
			if (this.SwigDerivedClassHasMethod("updateGeometry", OdGsBaseVectorizeDevice.swigMethodTypes8))
			{
				this.swigDelegate8 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_8(this.SwigDirectorupdateGeometry);
			}
			if (this.SwigDerivedClassHasMethod("updateScreen", OdGsBaseVectorizeDevice.swigMethodTypes9))
			{
				this.swigDelegate9 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_9(this.SwigDirectorupdateScreen);
			}
			if (this.SwigDerivedClassHasMethod("onRealizeForegroundPalette", OdGsBaseVectorizeDevice.swigMethodTypes10))
			{
				this.swigDelegate10 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_10(this.SwigDirectoronRealizeForegroundPalette);
			}
			if (this.SwigDerivedClassHasMethod("onRealizeBackgroundPalette", OdGsBaseVectorizeDevice.swigMethodTypes11))
			{
				this.swigDelegate11 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_11(this.SwigDirectoronRealizeBackgroundPalette);
			}
			if (this.SwigDerivedClassHasMethod("onDisplayChange", OdGsBaseVectorizeDevice.swigMethodTypes12))
			{
				this.swigDelegate12 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_12(this.SwigDirectoronDisplayChange);
			}
			if (this.SwigDerivedClassHasMethod("createView", OdGsBaseVectorizeDevice.swigMethodTypes13))
			{
				this.swigDelegate13 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_13(this.SwigDirectorcreateView__SWIG_0);
			}
			if (this.SwigDerivedClassHasMethod("createView", OdGsBaseVectorizeDevice.swigMethodTypes14))
			{
				this.swigDelegate14 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_14(this.SwigDirectorcreateView__SWIG_1);
			}
			if (this.SwigDerivedClassHasMethod("createView", OdGsBaseVectorizeDevice.swigMethodTypes15))
			{
				this.swigDelegate15 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_15(this.SwigDirectorcreateView__SWIG_2);
			}
			if (this.SwigDerivedClassHasMethod("addView", OdGsBaseVectorizeDevice.swigMethodTypes16))
			{
				this.swigDelegate16 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_16(this.SwigDirectoraddView);
			}
			if (this.SwigDerivedClassHasMethod("insertView", OdGsBaseVectorizeDevice.swigMethodTypes17))
			{
				this.swigDelegate17 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_17(this.SwigDirectorinsertView);
			}
			if (this.SwigDerivedClassHasMethod("setLogicalPalette", OdGsBaseVectorizeDevice.swigMethodTypes18))
			{
				this.swigDelegate18 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_18(this.SwigDirectorsetLogicalPalette);
			}
			if (this.SwigDerivedClassHasMethod("getSnapShot", OdGsBaseVectorizeDevice.swigMethodTypes19))
			{
				this.swigDelegate19 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_19(this.SwigDirectorgetSnapShot);
			}
			if (this.SwigDerivedClassHasMethod("createModel", OdGsBaseVectorizeDevice.swigMethodTypes20))
			{
				this.swigDelegate20 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_20(this.SwigDirectorcreateModel);
			}
			if (this.SwigDerivedClassHasMethod("isModelCompatible", OdGsBaseVectorizeDevice.swigMethodTypes21))
			{
				this.swigDelegate21 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_21(this.SwigDirectorisModelCompatible);
			}
			if (this.SwigDerivedClassHasMethod("renderTypeWeight", OdGsBaseVectorizeDevice.swigMethodTypes22))
			{
				this.swigDelegate22 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_22(this.SwigDirectorrenderTypeWeight);
			}
			if (this.SwigDerivedClassHasMethod("transientRenderType", OdGsBaseVectorizeDevice.swigMethodTypes23))
			{
				this.swigDelegate23 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_23(this.SwigDirectortransientRenderType);
			}
			if (this.SwigDerivedClassHasMethod("renderTypeOverlay", OdGsBaseVectorizeDevice.swigMethodTypes24))
			{
				this.swigDelegate24 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_24(this.SwigDirectorrenderTypeOverlay);
			}
			if (this.SwigDerivedClassHasMethod("isSupportDeviceStateSaving", OdGsBaseVectorizeDevice.swigMethodTypes25))
			{
				this.swigDelegate25 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_25(this.SwigDirectorisSupportDeviceStateSaving);
			}
			if (this.SwigDerivedClassHasMethod("saveClientDeviceState", OdGsBaseVectorizeDevice.swigMethodTypes26))
			{
				this.swigDelegate26 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_26(this.SwigDirectorsaveClientDeviceState);
			}
			if (this.SwigDerivedClassHasMethod("loadClientDeviceState", OdGsBaseVectorizeDevice.swigMethodTypes27))
			{
				this.swigDelegate27 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_27(this.SwigDirectorloadClientDeviceState);
			}
			if (this.SwigDerivedClassHasMethod("saveLinkedDeviceState", OdGsBaseVectorizeDevice.swigMethodTypes28))
			{
				this.swigDelegate28 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_28(this.SwigDirectorsaveLinkedDeviceState);
			}
			if (this.SwigDerivedClassHasMethod("loadLinkedDeviceState", OdGsBaseVectorizeDevice.swigMethodTypes29))
			{
				this.swigDelegate29 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_29(this.SwigDirectorloadLinkedDeviceState);
			}
			if (this.SwigDerivedClassHasMethod("supportParallelDisplay", OdGsBaseVectorizeDevice.swigMethodTypes30))
			{
				this.swigDelegate30 = new OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_30(this.SwigDirectorsupportParallelDisplay);
			}
			GlobalsPINVOKE.OdGsBaseVectorizeDevice_director_connect(this.swigCPtr, this.swigDelegate0, this.swigDelegate1, this.swigDelegate2, this.swigDelegate3, this.swigDelegate4, this.swigDelegate5, this.swigDelegate6, this.swigDelegate7, this.swigDelegate8, this.swigDelegate9, this.swigDelegate10, this.swigDelegate11, this.swigDelegate12, this.swigDelegate13, this.swigDelegate14, this.swigDelegate15, this.swigDelegate16, this.swigDelegate17, this.swigDelegate18, this.swigDelegate19, this.swigDelegate20, this.swigDelegate21, this.swigDelegate22, this.swigDelegate23, this.swigDelegate24, this.swigDelegate25, this.swigDelegate26, this.swigDelegate27, this.swigDelegate28, this.swigDelegate29, this.swigDelegate30);
		}

		private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes)
		{
			MethodInfo method = base.GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, methodTypes, null);
			return method.DeclaringType.IsSubclassOf(typeof(OdGsBaseVectorizeDevice));
		}

		private bool SwigDirectorsupportPartialUpdate()
		{
			return this.supportPartialUpdate();
		}

		private IntPtr SwigDirectorisA()
		{
			return OdRxClass.getCPtr(this.isA()).Handle;
		}

		private IntPtr SwigDirectorqueryX(IntPtr protocolClass)
		{
			return OdRxObject.getCPtr(this.queryX((OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(protocolClass, false))).Handle;
		}

		private IntPtr SwigDirectoruserGiContext()
		{
			return OdGiContext.getCPtr(this.userGiContext()).Handle;
		}

		private void SwigDirectorsetUserGiContext(IntPtr pUserGiContext)
		{
			this.setUserGiContext((OdGiContext)Teigha.Core.Helpers.odrxCreateObjectInternal(pUserGiContext, false));
		}

		private IntPtr SwigDirectorproperties()
		{
			return OdRxDictionary.getCPtr(this.properties()).Handle;
		}

		private void SwigDirectorinvalidate(IntPtr screenRect)
		{
			this.invalidate(new OdGsDCRect(screenRect, false));
		}

		private void SwigDirectorupdate(IntPtr pUpdatedRect)
		{
			this.update((pUpdatedRect == IntPtr.Zero) ? null : new OdGsDCRect(pUpdatedRect, false));
		}

		private void SwigDirectorupdateGeometry()
		{
			this.updateGeometry();
		}

		private void SwigDirectorupdateScreen()
		{
			this.updateScreen();
		}

		private void SwigDirectoronRealizeForegroundPalette()
		{
			this.onRealizeForegroundPalette();
		}

		private void SwigDirectoronRealizeBackgroundPalette()
		{
			this.onRealizeBackgroundPalette();
		}

		private void SwigDirectoronDisplayChange(int bitsPerPixel, int xPixels, int yPixels)
		{
			this.onDisplayChange(bitsPerPixel, xPixels, yPixels);
		}

		private IntPtr SwigDirectorcreateView__SWIG_0(IntPtr pViewInfo, bool enableLayerVisibilityPerView)
		{
			return OdGsView.getCPtr(this.createView((pViewInfo == IntPtr.Zero) ? null : new OdGsClientViewInfo(pViewInfo, false), enableLayerVisibilityPerView)).Handle;
		}

		private IntPtr SwigDirectorcreateView__SWIG_1(IntPtr pViewInfo)
		{
			return OdGsView.getCPtr(this.createView((pViewInfo == IntPtr.Zero) ? null : new OdGsClientViewInfo(pViewInfo, false))).Handle;
		}

		private IntPtr SwigDirectorcreateView__SWIG_2()
		{
			return OdGsView.getCPtr(this.createView()).Handle;
		}

		private void SwigDirectoraddView(IntPtr pView)
		{
			this.addView((OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(pView, false));
		}

		private void SwigDirectorinsertView(int viewIndex, IntPtr pView)
		{
			this.insertView(viewIndex, (OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(pView, false));
		}

		private void SwigDirectorsetLogicalPalette(uint[] logicalPalette, int numColors)
		{
			this.setLogicalPalette(logicalPalette, numColors);
		}

		private void SwigDirectorgetSnapShot(out IntPtr pImage, IntPtr region)
		{
			OdGiRasterImage obj = OdGiRasterImage.createObject();
			try
			{
				this.getSnapShot(out obj, new OdGsDCRect(region, false));
			}
			finally
			{
				pImage = OdGiRasterImage.getCPtr(obj).Handle;
			}
		}

		private IntPtr SwigDirectorcreateModel()
		{
			return OdGsModel.getCPtr(this.createModel()).Handle;
		}

		private bool SwigDirectorisModelCompatible(IntPtr pModel)
		{
			return this.isModelCompatible((OdGsModel)Teigha.Core.Helpers.odrxCreateObjectInternal(pModel, false));
		}

		private uint SwigDirectorrenderTypeWeight(int renderType)
		{
			return this.renderTypeWeight((OdGsModel.RenderType)renderType);
		}

		private int SwigDirectortransientRenderType()
		{
			return (int)this.transientRenderType();
		}

		private uint SwigDirectorrenderTypeOverlay(int renderType)
		{
			return this.renderTypeOverlay((OdGsModel.RenderType)renderType);
		}

		private bool SwigDirectorisSupportDeviceStateSaving()
		{
			return this.isSupportDeviceStateSaving();
		}

		private bool SwigDirectorsaveClientDeviceState(IntPtr pFiler)
		{
			return this.saveClientDeviceState((pFiler == IntPtr.Zero) ? null : new SWIGTYPE_p_OdGsFiler(pFiler, false));
		}

		private bool SwigDirectorloadClientDeviceState(IntPtr pFiler)
		{
			return this.loadClientDeviceState((pFiler == IntPtr.Zero) ? null : new SWIGTYPE_p_OdGsFiler(pFiler, false));
		}

		private bool SwigDirectorsaveLinkedDeviceState(IntPtr pFiler)
		{
			return this.saveLinkedDeviceState((pFiler == IntPtr.Zero) ? null : new SWIGTYPE_p_OdGsFiler(pFiler, false));
		}

		private bool SwigDirectorloadLinkedDeviceState(IntPtr pFiler)
		{
			return this.loadLinkedDeviceState((pFiler == IntPtr.Zero) ? null : new SWIGTYPE_p_OdGsFiler(pFiler, false));
		}

		private bool SwigDirectorsupportParallelDisplay()
		{
			return this.supportParallelDisplay();
		}

		private object locker = new object();

		private HandleRef swigCPtr;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_0 swigDelegate0;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_1 swigDelegate1;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_2 swigDelegate2;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_3 swigDelegate3;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_4 swigDelegate4;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_5 swigDelegate5;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_6 swigDelegate6;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_7 swigDelegate7;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_8 swigDelegate8;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_9 swigDelegate9;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_10 swigDelegate10;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_11 swigDelegate11;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_12 swigDelegate12;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_13 swigDelegate13;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_14 swigDelegate14;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_15 swigDelegate15;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_16 swigDelegate16;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_17 swigDelegate17;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_18 swigDelegate18;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_19 swigDelegate19;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_20 swigDelegate20;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_21 swigDelegate21;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_22 swigDelegate22;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_23 swigDelegate23;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_24 swigDelegate24;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_25 swigDelegate25;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_26 swigDelegate26;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_27 swigDelegate27;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_28 swigDelegate28;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_29 swigDelegate29;

		private OdGsBaseVectorizeDevice.SwigDelegateOdGsBaseVectorizeDevice_30 swigDelegate30;

		private static Type[] swigMethodTypes0 = new Type[0];

		private static Type[] swigMethodTypes1 = new Type[0];

		private static Type[] swigMethodTypes2 = new Type[]
		{
			typeof(OdRxClass)
		};

		private static Type[] swigMethodTypes3 = new Type[0];

		private static Type[] swigMethodTypes4 = new Type[]
		{
			typeof(OdGiContext)
		};

		private static Type[] swigMethodTypes5 = new Type[0];

		private static Type[] swigMethodTypes6 = new Type[]
		{
			typeof(OdGsDCRect)
		};

		private static Type[] swigMethodTypes7 = new Type[]
		{
			typeof(OdGsDCRect)
		};

		private static Type[] swigMethodTypes8 = new Type[0];

		private static Type[] swigMethodTypes9 = new Type[0];

		private static Type[] swigMethodTypes10 = new Type[0];

		private static Type[] swigMethodTypes11 = new Type[0];

		private static Type[] swigMethodTypes12 = new Type[]
		{
			typeof(int),
			typeof(int),
			typeof(int)
		};

		private static Type[] swigMethodTypes13 = new Type[]
		{
			typeof(OdGsClientViewInfo),
			typeof(bool)
		};

		private static Type[] swigMethodTypes14 = new Type[]
		{
			typeof(OdGsClientViewInfo)
		};

		private static Type[] swigMethodTypes15 = new Type[0];

		private static Type[] swigMethodTypes16 = new Type[]
		{
			typeof(OdGsView)
		};

		private static Type[] swigMethodTypes17 = new Type[]
		{
			typeof(int),
			typeof(OdGsView)
		};

		private static Type[] swigMethodTypes18 = new Type[]
		{
			typeof(uint[]),
			typeof(int)
		};

		private static Type[] swigMethodTypes19 = new Type[]
		{
			typeof(OdGiRasterImage).MakeByRefType(),
			typeof(OdGsDCRect)
		};

		private static Type[] swigMethodTypes20 = new Type[0];

		private static Type[] swigMethodTypes21 = new Type[]
		{
			typeof(OdGsModel)
		};

		private static Type[] swigMethodTypes22 = new Type[]
		{
			typeof(OdGsModel.RenderType)
		};

		private static Type[] swigMethodTypes23 = new Type[0];

		private static Type[] swigMethodTypes24 = new Type[]
		{
			typeof(OdGsModel.RenderType)
		};

		private static Type[] swigMethodTypes25 = new Type[0];

		private static Type[] swigMethodTypes26 = new Type[]
		{
			typeof(SWIGTYPE_p_OdGsFiler)
		};

		private static Type[] swigMethodTypes27 = new Type[]
		{
			typeof(SWIGTYPE_p_OdGsFiler)
		};

		private static Type[] swigMethodTypes28 = new Type[]
		{
			typeof(SWIGTYPE_p_OdGsFiler)
		};

		private static Type[] swigMethodTypes29 = new Type[]
		{
			typeof(SWIGTYPE_p_OdGsFiler)
		};

		private static Type[] swigMethodTypes30 = new Type[0];

		public delegate bool SwigDelegateOdGsBaseVectorizeDevice_0();

		public delegate IntPtr SwigDelegateOdGsBaseVectorizeDevice_1();

		public delegate IntPtr SwigDelegateOdGsBaseVectorizeDevice_2(IntPtr protocolClass);

		public delegate IntPtr SwigDelegateOdGsBaseVectorizeDevice_3();

		public delegate void SwigDelegateOdGsBaseVectorizeDevice_4(IntPtr pUserGiContext);

		public delegate IntPtr SwigDelegateOdGsBaseVectorizeDevice_5();

		public delegate void SwigDelegateOdGsBaseVectorizeDevice_6(IntPtr screenRect);

		public delegate void SwigDelegateOdGsBaseVectorizeDevice_7(IntPtr pUpdatedRect);

		public delegate void SwigDelegateOdGsBaseVectorizeDevice_8();

		public delegate void SwigDelegateOdGsBaseVectorizeDevice_9();

		public delegate void SwigDelegateOdGsBaseVectorizeDevice_10();

		public delegate void SwigDelegateOdGsBaseVectorizeDevice_11();

		public delegate void SwigDelegateOdGsBaseVectorizeDevice_12(int bitsPerPixel, int xPixels, int yPixels);

		public delegate IntPtr SwigDelegateOdGsBaseVectorizeDevice_13(IntPtr pViewInfo, bool enableLayerVisibilityPerView);

		public delegate IntPtr SwigDelegateOdGsBaseVectorizeDevice_14(IntPtr pViewInfo);

		public delegate IntPtr SwigDelegateOdGsBaseVectorizeDevice_15();

		public delegate void SwigDelegateOdGsBaseVectorizeDevice_16(IntPtr pView);

		public delegate void SwigDelegateOdGsBaseVectorizeDevice_17(int viewIndex, IntPtr pView);

		public delegate void SwigDelegateOdGsBaseVectorizeDevice_18(uint[] logicalPalette, int numColors);

		public delegate void SwigDelegateOdGsBaseVectorizeDevice_19(out IntPtr pImage, IntPtr region);

		public delegate IntPtr SwigDelegateOdGsBaseVectorizeDevice_20();

		public delegate bool SwigDelegateOdGsBaseVectorizeDevice_21(IntPtr pModel);

		public delegate uint SwigDelegateOdGsBaseVectorizeDevice_22(int renderType);

		public delegate int SwigDelegateOdGsBaseVectorizeDevice_23();

		public delegate uint SwigDelegateOdGsBaseVectorizeDevice_24(int renderType);

		public delegate bool SwigDelegateOdGsBaseVectorizeDevice_25();

		public delegate bool SwigDelegateOdGsBaseVectorizeDevice_26(IntPtr pFiler);

		public delegate bool SwigDelegateOdGsBaseVectorizeDevice_27(IntPtr pFiler);

		public delegate bool SwigDelegateOdGsBaseVectorizeDevice_28(IntPtr pFiler);

		public delegate bool SwigDelegateOdGsBaseVectorizeDevice_29(IntPtr pFiler);

		public delegate bool SwigDelegateOdGsBaseVectorizeDevice_30();
	}
}
